home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / parcs / readme.doc < prev   
Text File  |  1992-06-07  |  6KB  |  212 lines
  1.        <PARCS Ver 1.0 Users' Manual>
  2.  
  3. This is a users' manual for pseudo-parallel version of PARCS (PARallel
  4. Constraint Solving). PARCS is a parallel constraint logic programming
  5. language whose computational domain is Herbrand Universe and finite
  6. domains (symbol, integer).  Though program syntax is similar to that of 
  7. Prolog, you have to take care because semantics is rather different (
  8. especially ',' and ';' ).
  9. You also have to be careful in memory usage. Inappropriate environment
  10. setting may cause the memory usage to explode.
  11.  
  12. Our paper on pseudo-parallel version of PARCS is ftp available
  13. (~ftp/pub/papers/lpc91-parcs-a4.ps.Z). 
  14. Real parallel version for iPSC/2, Luna88k, and AP1000 will also be ftp
  15. available in future.
  16.  
  17.  
  18. [0]. Makefile
  19.  
  20. Source files  are in ~ftp/pub/parcs/source.
  21. Makefiles are
  22.     Makefile.sun4         for Sun SPARC Station
  23.     Makefile.luna88k    for Luna88k
  24.     Makefile.next        for NeXT
  25.  
  26. So you can make program by the following command:
  27.   % mv Makefile.sun4 Makefile
  28.   % make
  29.  
  30. [1]. Invocation and Termination of PARCS
  31.  
  32.     If you execute the command 'parcs', the following prompt appears.
  33.  
  34.     <PARCS>
  35.     
  36.     Command to terminate program is #quit.
  37.  
  38.     <PARCS>#quit.
  39.     %
  40.  
  41.  
  42. [2]. Top Level
  43.  
  44.     In the top level (when the prompt <PARCS> appears),
  45.     you can execute the following:
  46.  
  47.       (A) Special Command
  48.            The command whose first letter is '#'.
  49.  
  50.       (B) Definition of Clause 
  51.  
  52.       (C) Query
  53.  
  54.  
  55. [3]. Special Command
  56.  
  57.     The following commands are available.
  58.     Strings in arguments should be enclosed by '"'
  59.  
  60.   #cwd
  61.       Syntax   #cwd(<directry name>).
  62.       Semantics     Change current Working Directry
  63.  
  64.   #learn-and
  65.  
  66.   #learn-or
  67.  
  68.   #load
  69.       Syntax   #load(<file name>).
  70.       Semantics   Recover the environment that was saved in the file.
  71.           ".cod" is automatically added to the file name.
  72.  
  73.   #msize
  74.       Syntax   #msize <chunk size>.
  75.       Semantics   Change memory size. Try to execute this command when
  76.         the message "Out of Memory" is reported.
  77.         Size should be 4196, 8192, 16384, 32768,...
  78.  
  79.   #pred
  80.  
  81.   #priority
  82.  
  83.   #read
  84.       Syntax   #read(<file name>).
  85.       Semantics  Read program.
  86.                 ".parcs" is automatically added to the file name.
  87.  
  88.   #quit
  89.       Syntax   #quit.
  90.       Semantics  Quit parcs.
  91.  
  92.   #save
  93.       Syntax   #save(<file name>).
  94.       Semantics Save the current environment (definition of clauses, priority parameter)
  95.         to the file. ".cod" is automatically added to the file name.
  96.  
  97.   #set
  98.  
  99.   #setprior
  100.  
  101.   #shell
  102.       Syntax   #shell(<shell command>).
  103.       Semantics  Execute shell command.
  104.  
  105.  
  106. [4] Program Syntax
  107.  
  108.   Sample programs are in ~ftp/parcs/sample
  109.  
  110.   [3.1]definition of finite domains
  111.  
  112.       Declaration of finite domain name is the form of
  113.            defdomain  <domain name>  <domain>.
  114.  
  115.       Declaration of domain variable is
  116.            <domain name>(<variable sequence>) 
  117.  
  118.  
  119.  
  120.       [Example]
  121.            defdomain  foo    int{-1,1,3,5}.
  122.            defdomain  bar    int{1..9}.
  123.            defdomain  baz    foo{0..4}.       /* intersection of foo and {0..4} */
  124.            defdomain  tako   {a,b,c,d}.       /* finite sets of symbol */
  125.  
  126.        p(X) :- foo(X),        /* The value of X is one of {-1,1,3,5}.*/
  127.            ...
  128.         
  129.  
  130.  
  131.   [3.2]Clause and Goal
  132.  
  133.      Clause is the form of
  134.          Head :- Body.
  135.      and goal is the form of
  136.          :- Body.
  137.  
  138.      Body is the sequence of atoms constraints, declarations of domain variables.
  139.      If you write 
  140.          p :- q, r.
  141.      then q and r is executed in parallel.
  142.           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  143.      To specify explicitly the sequential execution, please use ';' instead of ","
  144.      as follows:
  145.          p :- q; r.
  146.  
  147.      [Example]
  148.            :- q, r.     /* q, r is executed in parallel */
  149.            :- q; r.     /* q, r is sequentially executed   */
  150.            :- q; r,s.   /* q is executed at first, then r and s are executed in parallel */
  151.            :- q, (r;s). /* q and r are executed in parallel, then after r is resolved,
  152.                 s is executed */
  153.  
  154.   [3.3]Setting of priority parameter
  155.  
  156.       Use #priority command. (See paper)
  157.  
  158.  
  159.   [3.4]Comment
  160.  
  161.       /*  */ 
  162.  
  163.  
  164.   [3.X] Syntax
  165.  
  166.      Whole syntax is as follows:
  167.  
  168.      <statement>  ::=  <defdomain> | <clause> | { <system-command>} 
  169.      <defdomain>  ::=  {defdomain} <dname> (<dname>)<set> 
  170.      <dname>  ::=  <symbol> 
  171.      <set>        ::=  { <range> } | { <int-sequence> } | 
  172.                   { <sym-sequence> } 
  173.      <range>      ::=  <integer> .. <integer> 
  174.      <int-sequence>  ::=  <integer> {, <integer>} 
  175.      <sym-sequence>  ::=  <symbol>  {, <symbol>} 
  176.      <clause>     ::=  <head> .| 
  177.               <head> :- <body>| 
  178.               {:-} <body> 
  179.      <head>       ::=  <atom> 
  180.      <body>       ::=  <seq-literals> 
  181.      <seq-literals>  ::=  <par-literals> {; <par-literals>} 
  182.      <par-literals>  ::=  <unit-literal> {, <unit-literal>} 
  183.      <unit-literal>  ::=  <literal> | ( <seq-literals> ) 
  184.      <literal>    ::=  <atom> | <s-constraint> | <m-constraint>  
  185.      <atom>       ::=  <predicate> | 
  186.          ::=  <predicate> ( <term> { , <term>} )  
  187.      <sym-expression>  ::=  <term> <sym-predicate> <term> 
  188.      <math-expression>  ::=  <integer> | <variable> | 
  189.                         - <expression> | 
  190.                         ( <expression> )| 
  191.                         <expression> <math-predicate> <expression> 
  192.      <expression>  ::=  <expression> <operator> <expression> 
  193.      <sym-predicate>  ::=  == | !== 
  194.      <math-predicate>  ::=  = | != | < | > | <= | >=
  195.      <operator>   ::=  + | - | * | div | mod 
  196.      <term>       ::=  <integer> | <symbol> | <variable> | 
  197.              <func-term> | <list-term>  
  198.      <func-term>  ::=  <symbol> ( <term> { , <term>} )  
  199.      <list-term>  ::=  [ ] | [<term> { , <term>} (|<term>)] 
  200.  
  201.  
  202.  
  203. [X]. Questions and comments are welcome to koba@is.s.u-tokyo.ac.jp
  204.  
  205.  
  206.  
  207.  
  208.  
  209.  
  210.  
  211.  
  212.